#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;

//class Solution {
//public:
//    int maxSubArray(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> dp(n);
//        dp[0] = nums[0];
//        for (int i = 1; i < n; i++)
//        {
//            dp[i] = dp[i - 1] + nums[i];
//        }
//
//
//        int min_ = nums[0], ret = nums[0];
//        for (int i = 1; i < n; i++)
//        {
//            ret = max(ret, min_ < 0 ? dp[i] - min_ : dp[i]);
//            min_ = min(dp[i], min_);
//        }
//
//        return ret;
//    }
//};
//
//class Solution {
//public:
//    int maxSubArray(vector<int>& nums) {
//        int n = nums.size();
//        int dp = nums[0];
//
//
//        int min_ = nums[0], ret = nums[0];
//        for (int i = 1; i < n; i++)
//        {
//            dp += nums[i];
//            ret = max(ret, min_ < 0 ? dp - min_ : dp);
//            min_ = min(dp, min_);
//        }
//
//        return ret;
//    }
//};
//
//class Solution {
//public:
//    vector<vector<int>> merge(vector<vector<int>>& in)
//    {
//        int n = in.size();
//        vector<vector<int>> ret;
//        sort(in.begin(), in.end(), [](const vector<int>& t1, const vector<int>& t2) {
//            return t1[0] < t2[0];
//            });
//
//        ret.push_back({ in[0] });
//        for (int i = 1; i < n; i++)
//        {
//            if (ret.back()[1] >= in[i][0])
//            {
//                ret.back()[1] = max(in[i][1], ret.back()[1]);
//            }
//            else
//            {
//                ret.push_back(in[i]);
//            }
//        }
//
//        return ret;
//    }
//};
//
//class Solution {
//public:
//
//    void Reverse(vector<int>& nums, int left, int right)
//    {
//        while (left < right)
//        {
//            swap(nums[left], nums[right]);
//            left++;
//            right--;
//        }
//    }
//
//    void rotate(vector<int>& nums, int k) {
//        int n = nums.size();
//        k %= n;
//
//        Reverse(nums, 0, n - 1);
//        Reverse(nums, 0, k - 1);
//        Reverse(nums, k, n - 1);
//
//    }
//};
//
//class Solution {
//public:
//    vector<int> productExceptSelf(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> ret(n);
//
//        ret[n - 1] = 1;
//        for (int i = n - 2; i >= 0; i--)
//        {
//            ret[i] = ret[i + 1] * nums[i + 1];
//        }
//
//        int pre = 1;
//        for (int i = 1; i < n; i++)
//        {
//            pre *= nums[i - 1];
//            ret[i] = ret[i] * pre;
//        }
//
//        return ret;
//    }
//};

//class Solution {
//public:
//    int firstMissingPositive(vector<int>& nums) {
//        int n = nums.size();
//        for (int i = 0; i < n; i++)
//        {
//            while (nums[i] >= 1 && nums[i] <= n && nums[i] != nums[nums[i] - 1])
//            {
//                swap(nums[i], nums[nums[i] - 1]);
//            }
//        }
//
//        int i = 0;
//        for (; i < nums.size(); i++)
//        {
//            if (nums[i] != i + 1) return i + 1;
//        }
//
//        return i + 1;
//    }
//};
//
//
//class Solution {
//public:
//    int numberOfPoints(vector<vector<int>>& nums)
//    {
//        sort(nums.begin(), nums.end(), [](vector<int>& v1, vector<int>& v2)
//            {
//                if (v1[0] == v2[0])
//                    return v1[1] < v2[1];
//                return v1[0] < v2[0];
//            });
//
//        int l = 0, r = 0;
//        int ret = 0;
//        for (int i = 0; i < nums.size(); i++)
//        {
//            if (r >= nums[i][0] && r < nums[i][1])
//            {
//                ret += nums[i][1] - r;
//                r = nums[i][1];
//            }
//            else if (r < nums[i][0])
//            {
//                ret += nums[i][1] - nums[i][0] + 1;
//                l = nums[i][0];
//                r = nums[i][1];
//            }
//        }
//
//        return ret;
//
//    }
//};

class Solution {
public:
    int distanceBetweenBusStops(vector<int>& distance, int start, int destination)
    {
        int n = distance.size();
        int next = 0;
        int i = start;
        while (i != destination)
        {
            next += distance[i];
            i++;
            if (i == n)

                i %= n;
        }


        int prev = 0;
        i = start;
        while (i != destination)
        {
            if (i != 0)
            {
                prev += distance[i - 1];
            }
            else
                prev += distance[n - 1];

            i--;
            if (i == -1)
                i = n - 1;
        }

        return min(next, prev);

    }
};

int main()
{
    vector<int> arr = { 1,2,3,4 };
    Solution().distanceBetweenBusStops(arr, 0, 1);
    return 0;
}